// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.supplier.invoice.order.product;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.SupplierInvoiceOrderProduct;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(SupplierInvoiceOrderProduct.class)
@Setter
@Getter
public class SupplierInvoiceOrderProductSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "SupplierInvoiceOrderProduct".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("parentSupplierInvoiceOrder", "sio");
    map.put("name", "p");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 所属供应商发货单
   */
  private Long parentSupplierInvoiceOrder;

  /**
   * 所属供应商发货单 比较(eq)
   */
  private Long parentSupplierInvoiceOrderEq;
  /**
   * 所属供应商发货单 比较(neq)
   */
  private Long parentSupplierInvoiceOrderNeq;
  /**
   * 所属供应商发货单 比较(gt)
   */
  private Long parentSupplierInvoiceOrderGt;
  /**
   * 所属供应商发货单 比较(gte)
   */
  private Long parentSupplierInvoiceOrderGte;
  /**
   * 所属供应商发货单 比较(lt)
   */
  private Long parentSupplierInvoiceOrderLt;
  /**
   * 所属供应商发货单 比较(lte)
   */
  private Long parentSupplierInvoiceOrderLte;
  /**
   * 所属供应商发货单 比较(contains)
   */
  private Long parentSupplierInvoiceOrderContains;
  /**
   * 所属供应商发货单 比较(notcontains)
   */
  private Long parentSupplierInvoiceOrderNotcontains;
  /**
   * 所属供应商发货单 比较(startswith)
   */
  private Long parentSupplierInvoiceOrderStartswith;
  /**
   * 所属供应商发货单 比较(endswith)
   */
  private Long parentSupplierInvoiceOrderEndswith;
  /**
   * 所属供应商发货单 比较(isnull)
   */
  private Boolean parentSupplierInvoiceOrderIsnull;
  /**
   * 所属供应商发货单 比较(isnotnull)
   */
  private Boolean parentSupplierInvoiceOrderIsnotnull;
  /**
   * 所属供应商发货单的供应商编号 比较(eq)
   */
  private String parentSupplierInvoiceOrderSupplierIdEq;
  /**
   * 所属供应商发货单的供应商编号 比较(neq)
   */
  private String parentSupplierInvoiceOrderSupplierIdNeq;
  /**
   * 所属供应商发货单的供应商编号 比较(gt)
   */
  private String parentSupplierInvoiceOrderSupplierIdGt;
  /**
   * 所属供应商发货单的供应商编号 比较(gte)
   */
  private String parentSupplierInvoiceOrderSupplierIdGte;
  /**
   * 所属供应商发货单的供应商编号 比较(lt)
   */
  private String parentSupplierInvoiceOrderSupplierIdLt;
  /**
   * 所属供应商发货单的供应商编号 比较(lte)
   */
  private String parentSupplierInvoiceOrderSupplierIdLte;
  /**
   * 所属供应商发货单的供应商编号 比较(contains)
   */
  private String parentSupplierInvoiceOrderSupplierIdContains;
  /**
   * 所属供应商发货单的供应商编号 比较(notcontains)
   */
  private String parentSupplierInvoiceOrderSupplierIdNotcontains;
  /**
   * 所属供应商发货单的供应商编号 比较(startswith)
   */
  private String parentSupplierInvoiceOrderSupplierIdStartswith;
  /**
   * 所属供应商发货单的供应商编号 比较(endswith)
   */
  private String parentSupplierInvoiceOrderSupplierIdEndswith;
  /**
   * 所属供应商发货单的供应商编号 比较(isnull)
   */
  private Boolean parentSupplierInvoiceOrderSupplierIdIsnull;
  /**
   * 所属供应商发货单的供应商编号 比较(isnotnull)
   */
  private Boolean parentSupplierInvoiceOrderSupplierIdIsnotnull;

  /**
   * 所属供应商发货单(范围搜索)
   */
  private List<Long> parentSupplierInvoiceOrderInList;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 所属发货单(模糊搜索)
   */
  private String supplierInvoiceOrderId;

  /**
   * 所属发货单 比较(eq)
   */
  private String supplierInvoiceOrderIdEq;
  /**
   * 所属发货单 比较(neq)
   */
  private String supplierInvoiceOrderIdNeq;
  /**
   * 所属发货单 比较(gt)
   */
  private String supplierInvoiceOrderIdGt;
  /**
   * 所属发货单 比较(gte)
   */
  private String supplierInvoiceOrderIdGte;
  /**
   * 所属发货单 比较(lt)
   */
  private String supplierInvoiceOrderIdLt;
  /**
   * 所属发货单 比较(lte)
   */
  private String supplierInvoiceOrderIdLte;
  /**
   * 所属发货单 比较(contains)
   */
  private String supplierInvoiceOrderIdContains;
  /**
   * 所属发货单 比较(notcontains)
   */
  private String supplierInvoiceOrderIdNotcontains;
  /**
   * 所属发货单 比较(startswith)
   */
  private String supplierInvoiceOrderIdStartswith;
  /**
   * 所属发货单 比较(endswith)
   */
  private String supplierInvoiceOrderIdEndswith;
  /**
   * 所属发货单 比较(isnull)
   */
  private Boolean supplierInvoiceOrderIdIsnull;
  /**
   * 所属发货单 比较(isnotnull)
   */
  private Boolean supplierInvoiceOrderIdIsnotnull;

  /**
   * 所属发货单(精确搜索)
   */
  private List<String> supplierInvoiceOrderIdInList;

  /**
   * 发货量
   */
  private Integer sendQuantity;

  /**
   * 最小发货量
   */
  private Integer sendQuantityMin;

  /**
   * 最大发货量
   */
  private Integer sendQuantityMax;

  /**
   * 发货量 比较(eq)
   */
  private Integer sendQuantityEq;
  /**
   * 发货量 比较(neq)
   */
  private Integer sendQuantityNeq;
  /**
   * 发货量 比较(gt)
   */
  private Integer sendQuantityGt;
  /**
   * 发货量 比较(gte)
   */
  private Integer sendQuantityGte;
  /**
   * 发货量 比较(lt)
   */
  private Integer sendQuantityLt;
  /**
   * 发货量 比较(lte)
   */
  private Integer sendQuantityLte;
  /**
   * 发货量 比较(contains)
   */
  private Integer sendQuantityContains;
  /**
   * 发货量 比较(notcontains)
   */
  private Integer sendQuantityNotcontains;
  /**
   * 发货量 比较(startswith)
   */
  private Integer sendQuantityStartswith;
  /**
   * 发货量 比较(endswith)
   */
  private Integer sendQuantityEndswith;
  /**
   * 发货量 比较(isnull)
   */
  private Boolean sendQuantityIsnull;
  /**
   * 发货量 比较(isnotnull)
   */
  private Boolean sendQuantityIsnotnull;

  /**
   * 总净重
   */
  private java.math.BigDecimal totalSuttle;

  /**
   * 最小总净重
   */
  private java.math.BigDecimal totalSuttleMin;

  /**
   * 最大总净重
   */
  private java.math.BigDecimal totalSuttleMax;

  /**
   * 总净重 比较(eq)
   */
  private java.math.BigDecimal totalSuttleEq;
  /**
   * 总净重 比较(neq)
   */
  private java.math.BigDecimal totalSuttleNeq;
  /**
   * 总净重 比较(gt)
   */
  private java.math.BigDecimal totalSuttleGt;
  /**
   * 总净重 比较(gte)
   */
  private java.math.BigDecimal totalSuttleGte;
  /**
   * 总净重 比较(lt)
   */
  private java.math.BigDecimal totalSuttleLt;
  /**
   * 总净重 比较(lte)
   */
  private java.math.BigDecimal totalSuttleLte;
  /**
   * 总净重 比较(contains)
   */
  private java.math.BigDecimal totalSuttleContains;
  /**
   * 总净重 比较(notcontains)
   */
  private java.math.BigDecimal totalSuttleNotcontains;
  /**
   * 总净重 比较(startswith)
   */
  private java.math.BigDecimal totalSuttleStartswith;
  /**
   * 总净重 比较(endswith)
   */
  private java.math.BigDecimal totalSuttleEndswith;
  /**
   * 总净重 比较(isnull)
   */
  private Boolean totalSuttleIsnull;
  /**
   * 总净重 比较(isnotnull)
   */
  private Boolean totalSuttleIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 总毛重
   */
  private java.math.BigDecimal totalGross;

  /**
   * 最小总毛重
   */
  private java.math.BigDecimal totalGrossMin;

  /**
   * 最大总毛重
   */
  private java.math.BigDecimal totalGrossMax;

  /**
   * 总毛重 比较(eq)
   */
  private java.math.BigDecimal totalGrossEq;
  /**
   * 总毛重 比较(neq)
   */
  private java.math.BigDecimal totalGrossNeq;
  /**
   * 总毛重 比较(gt)
   */
  private java.math.BigDecimal totalGrossGt;
  /**
   * 总毛重 比较(gte)
   */
  private java.math.BigDecimal totalGrossGte;
  /**
   * 总毛重 比较(lt)
   */
  private java.math.BigDecimal totalGrossLt;
  /**
   * 总毛重 比较(lte)
   */
  private java.math.BigDecimal totalGrossLte;
  /**
   * 总毛重 比较(contains)
   */
  private java.math.BigDecimal totalGrossContains;
  /**
   * 总毛重 比较(notcontains)
   */
  private java.math.BigDecimal totalGrossNotcontains;
  /**
   * 总毛重 比较(startswith)
   */
  private java.math.BigDecimal totalGrossStartswith;
  /**
   * 总毛重 比较(endswith)
   */
  private java.math.BigDecimal totalGrossEndswith;
  /**
   * 总毛重 比较(isnull)
   */
  private Boolean totalGrossIsnull;
  /**
   * 总毛重 比较(isnotnull)
   */
  private Boolean totalGrossIsnotnull;

  /**
   * 总体积
   */
  private java.math.BigDecimal totalVolume;

  /**
   * 最小总体积
   */
  private java.math.BigDecimal totalVolumeMin;

  /**
   * 最大总体积
   */
  private java.math.BigDecimal totalVolumeMax;

  /**
   * 总体积 比较(eq)
   */
  private java.math.BigDecimal totalVolumeEq;
  /**
   * 总体积 比较(neq)
   */
  private java.math.BigDecimal totalVolumeNeq;
  /**
   * 总体积 比较(gt)
   */
  private java.math.BigDecimal totalVolumeGt;
  /**
   * 总体积 比较(gte)
   */
  private java.math.BigDecimal totalVolumeGte;
  /**
   * 总体积 比较(lt)
   */
  private java.math.BigDecimal totalVolumeLt;
  /**
   * 总体积 比较(lte)
   */
  private java.math.BigDecimal totalVolumeLte;
  /**
   * 总体积 比较(contains)
   */
  private java.math.BigDecimal totalVolumeContains;
  /**
   * 总体积 比较(notcontains)
   */
  private java.math.BigDecimal totalVolumeNotcontains;
  /**
   * 总体积 比较(startswith)
   */
  private java.math.BigDecimal totalVolumeStartswith;
  /**
   * 总体积 比较(endswith)
   */
  private java.math.BigDecimal totalVolumeEndswith;
  /**
   * 总体积 比较(isnull)
   */
  private Boolean totalVolumeIsnull;
  /**
   * 总体积 比较(isnotnull)
   */
  private Boolean totalVolumeIsnotnull;

  /**
   * 品名
   */
  private Long name;

  /**
   * 品名 比较(eq)
   */
  private Long nameEq;
  /**
   * 品名 比较(neq)
   */
  private Long nameNeq;
  /**
   * 品名 比较(gt)
   */
  private Long nameGt;
  /**
   * 品名 比较(gte)
   */
  private Long nameGte;
  /**
   * 品名 比较(lt)
   */
  private Long nameLt;
  /**
   * 品名 比较(lte)
   */
  private Long nameLte;
  /**
   * 品名 比较(contains)
   */
  private Long nameContains;
  /**
   * 品名 比较(notcontains)
   */
  private Long nameNotcontains;
  /**
   * 品名 比较(startswith)
   */
  private Long nameStartswith;
  /**
   * 品名 比较(endswith)
   */
  private Long nameEndswith;
  /**
   * 品名 比较(isnull)
   */
  private Boolean nameIsnull;
  /**
   * 品名 比较(isnotnull)
   */
  private Boolean nameIsnotnull;
  /**
   * 品名的品名 比较(eq)
   */
  private String nameNameEq;
  /**
   * 品名的品名 比较(neq)
   */
  private String nameNameNeq;
  /**
   * 品名的品名 比较(gt)
   */
  private String nameNameGt;
  /**
   * 品名的品名 比较(gte)
   */
  private String nameNameGte;
  /**
   * 品名的品名 比较(lt)
   */
  private String nameNameLt;
  /**
   * 品名的品名 比较(lte)
   */
  private String nameNameLte;
  /**
   * 品名的品名 比较(contains)
   */
  private String nameNameContains;
  /**
   * 品名的品名 比较(notcontains)
   */
  private String nameNameNotcontains;
  /**
   * 品名的品名 比较(startswith)
   */
  private String nameNameStartswith;
  /**
   * 品名的品名 比较(endswith)
   */
  private String nameNameEndswith;
  /**
   * 品名的品名 比较(isnull)
   */
  private Boolean nameNameIsnull;
  /**
   * 品名的品名 比较(isnotnull)
   */
  private Boolean nameNameIsnotnull;

  /**
   * 品名(范围搜索)
   */
  private List<Long> nameInList;

  /**
   * SKU(模糊搜索)
   */
  private String sku;

  /**
   * SKU 比较(eq)
   */
  private String skuEq;
  /**
   * SKU 比较(neq)
   */
  private String skuNeq;
  /**
   * SKU 比较(gt)
   */
  private String skuGt;
  /**
   * SKU 比较(gte)
   */
  private String skuGte;
  /**
   * SKU 比较(lt)
   */
  private String skuLt;
  /**
   * SKU 比较(lte)
   */
  private String skuLte;
  /**
   * SKU 比较(contains)
   */
  private String skuContains;
  /**
   * SKU 比较(notcontains)
   */
  private String skuNotcontains;
  /**
   * SKU 比较(startswith)
   */
  private String skuStartswith;
  /**
   * SKU 比较(endswith)
   */
  private String skuEndswith;
  /**
   * SKU 比较(isnull)
   */
  private Boolean skuIsnull;
  /**
   * SKU 比较(isnotnull)
   */
  private Boolean skuIsnotnull;

  /**
   * SKU(精确搜索)
   */
  private List<String> skuInList;

  /**
   * 税费(模糊搜索)
   */
  private String taxAmount;

  /**
   * 税费 比较(eq)
   */
  private String taxAmountEq;
  /**
   * 税费 比较(neq)
   */
  private String taxAmountNeq;
  /**
   * 税费 比较(gt)
   */
  private String taxAmountGt;
  /**
   * 税费 比较(gte)
   */
  private String taxAmountGte;
  /**
   * 税费 比较(lt)
   */
  private String taxAmountLt;
  /**
   * 税费 比较(lte)
   */
  private String taxAmountLte;
  /**
   * 税费 比较(contains)
   */
  private String taxAmountContains;
  /**
   * 税费 比较(notcontains)
   */
  private String taxAmountNotcontains;
  /**
   * 税费 比较(startswith)
   */
  private String taxAmountStartswith;
  /**
   * 税费 比较(endswith)
   */
  private String taxAmountEndswith;
  /**
   * 税费 比较(isnull)
   */
  private Boolean taxAmountIsnull;
  /**
   * 税费 比较(isnotnull)
   */
  private Boolean taxAmountIsnotnull;

  /**
   * 税费(精确搜索)
   */
  private List<String> taxAmountInList;

  /**
   * 箱数
   */
  private Integer boxNum;

  /**
   * 最小箱数
   */
  private Integer boxNumMin;

  /**
   * 最大箱数
   */
  private Integer boxNumMax;

  /**
   * 箱数 比较(eq)
   */
  private Integer boxNumEq;
  /**
   * 箱数 比较(neq)
   */
  private Integer boxNumNeq;
  /**
   * 箱数 比较(gt)
   */
  private Integer boxNumGt;
  /**
   * 箱数 比较(gte)
   */
  private Integer boxNumGte;
  /**
   * 箱数 比较(lt)
   */
  private Integer boxNumLt;
  /**
   * 箱数 比较(lte)
   */
  private Integer boxNumLte;
  /**
   * 箱数 比较(contains)
   */
  private Integer boxNumContains;
  /**
   * 箱数 比较(notcontains)
   */
  private Integer boxNumNotcontains;
  /**
   * 箱数 比较(startswith)
   */
  private Integer boxNumStartswith;
  /**
   * 箱数 比较(endswith)
   */
  private Integer boxNumEndswith;
  /**
   * 箱数 比较(isnull)
   */
  private Boolean boxNumIsnull;
  /**
   * 箱数 比较(isnotnull)
   */
  private Boolean boxNumIsnotnull;

  /**
   * 箱规名称(模糊搜索)
   */
  private String boxList;

  /**
   * 箱规名称 比较(eq)
   */
  private String boxListEq;
  /**
   * 箱规名称 比较(neq)
   */
  private String boxListNeq;
  /**
   * 箱规名称 比较(gt)
   */
  private String boxListGt;
  /**
   * 箱规名称 比较(gte)
   */
  private String boxListGte;
  /**
   * 箱规名称 比较(lt)
   */
  private String boxListLt;
  /**
   * 箱规名称 比较(lte)
   */
  private String boxListLte;
  /**
   * 箱规名称 比较(contains)
   */
  private String boxListContains;
  /**
   * 箱规名称 比较(notcontains)
   */
  private String boxListNotcontains;
  /**
   * 箱规名称 比较(startswith)
   */
  private String boxListStartswith;
  /**
   * 箱规名称 比较(endswith)
   */
  private String boxListEndswith;
  /**
   * 箱规名称 比较(isnull)
   */
  private Boolean boxListIsnull;
  /**
   * 箱规名称 比较(isnotnull)
   */
  private Boolean boxListIsnotnull;

  /**
   * 箱规名称(精确搜索)
   */
  private List<String> boxListInList;

  /**
   * 箱子毛重（kg）
   */
  private java.math.BigDecimal boxGross;

  /**
   * 最小箱子毛重（kg）
   */
  private java.math.BigDecimal boxGrossMin;

  /**
   * 最大箱子毛重（kg）
   */
  private java.math.BigDecimal boxGrossMax;

  /**
   * 箱子毛重（kg） 比较(eq)
   */
  private java.math.BigDecimal boxGrossEq;
  /**
   * 箱子毛重（kg） 比较(neq)
   */
  private java.math.BigDecimal boxGrossNeq;
  /**
   * 箱子毛重（kg） 比较(gt)
   */
  private java.math.BigDecimal boxGrossGt;
  /**
   * 箱子毛重（kg） 比较(gte)
   */
  private java.math.BigDecimal boxGrossGte;
  /**
   * 箱子毛重（kg） 比较(lt)
   */
  private java.math.BigDecimal boxGrossLt;
  /**
   * 箱子毛重（kg） 比较(lte)
   */
  private java.math.BigDecimal boxGrossLte;
  /**
   * 箱子毛重（kg） 比较(contains)
   */
  private java.math.BigDecimal boxGrossContains;
  /**
   * 箱子毛重（kg） 比较(notcontains)
   */
  private java.math.BigDecimal boxGrossNotcontains;
  /**
   * 箱子毛重（kg） 比较(startswith)
   */
  private java.math.BigDecimal boxGrossStartswith;
  /**
   * 箱子毛重（kg） 比较(endswith)
   */
  private java.math.BigDecimal boxGrossEndswith;
  /**
   * 箱子毛重（kg） 比较(isnull)
   */
  private Boolean boxGrossIsnull;
  /**
   * 箱子毛重（kg） 比较(isnotnull)
   */
  private Boolean boxGrossIsnotnull;

  /**
   * 箱子长(cm)
   */
  private java.math.BigDecimal boxLength;

  /**
   * 最小箱子长(cm)
   */
  private java.math.BigDecimal boxLengthMin;

  /**
   * 最大箱子长(cm)
   */
  private java.math.BigDecimal boxLengthMax;

  /**
   * 箱子长(cm) 比较(eq)
   */
  private java.math.BigDecimal boxLengthEq;
  /**
   * 箱子长(cm) 比较(neq)
   */
  private java.math.BigDecimal boxLengthNeq;
  /**
   * 箱子长(cm) 比较(gt)
   */
  private java.math.BigDecimal boxLengthGt;
  /**
   * 箱子长(cm) 比较(gte)
   */
  private java.math.BigDecimal boxLengthGte;
  /**
   * 箱子长(cm) 比较(lt)
   */
  private java.math.BigDecimal boxLengthLt;
  /**
   * 箱子长(cm) 比较(lte)
   */
  private java.math.BigDecimal boxLengthLte;
  /**
   * 箱子长(cm) 比较(contains)
   */
  private java.math.BigDecimal boxLengthContains;
  /**
   * 箱子长(cm) 比较(notcontains)
   */
  private java.math.BigDecimal boxLengthNotcontains;
  /**
   * 箱子长(cm) 比较(startswith)
   */
  private java.math.BigDecimal boxLengthStartswith;
  /**
   * 箱子长(cm) 比较(endswith)
   */
  private java.math.BigDecimal boxLengthEndswith;
  /**
   * 箱子长(cm) 比较(isnull)
   */
  private Boolean boxLengthIsnull;
  /**
   * 箱子长(cm) 比较(isnotnull)
   */
  private Boolean boxLengthIsnotnull;

  /**
   * 箱子宽
   */
  private java.math.BigDecimal boxWidth;

  /**
   * 最小箱子宽
   */
  private java.math.BigDecimal boxWidthMin;

  /**
   * 最大箱子宽
   */
  private java.math.BigDecimal boxWidthMax;

  /**
   * 箱子宽 比较(eq)
   */
  private java.math.BigDecimal boxWidthEq;
  /**
   * 箱子宽 比较(neq)
   */
  private java.math.BigDecimal boxWidthNeq;
  /**
   * 箱子宽 比较(gt)
   */
  private java.math.BigDecimal boxWidthGt;
  /**
   * 箱子宽 比较(gte)
   */
  private java.math.BigDecimal boxWidthGte;
  /**
   * 箱子宽 比较(lt)
   */
  private java.math.BigDecimal boxWidthLt;
  /**
   * 箱子宽 比较(lte)
   */
  private java.math.BigDecimal boxWidthLte;
  /**
   * 箱子宽 比较(contains)
   */
  private java.math.BigDecimal boxWidthContains;
  /**
   * 箱子宽 比较(notcontains)
   */
  private java.math.BigDecimal boxWidthNotcontains;
  /**
   * 箱子宽 比较(startswith)
   */
  private java.math.BigDecimal boxWidthStartswith;
  /**
   * 箱子宽 比较(endswith)
   */
  private java.math.BigDecimal boxWidthEndswith;
  /**
   * 箱子宽 比较(isnull)
   */
  private Boolean boxWidthIsnull;
  /**
   * 箱子宽 比较(isnotnull)
   */
  private Boolean boxWidthIsnotnull;

  /**
   * 箱子高
   */
  private java.math.BigDecimal boxHeight;

  /**
   * 最小箱子高
   */
  private java.math.BigDecimal boxHeightMin;

  /**
   * 最大箱子高
   */
  private java.math.BigDecimal boxHeightMax;

  /**
   * 箱子高 比较(eq)
   */
  private java.math.BigDecimal boxHeightEq;
  /**
   * 箱子高 比较(neq)
   */
  private java.math.BigDecimal boxHeightNeq;
  /**
   * 箱子高 比较(gt)
   */
  private java.math.BigDecimal boxHeightGt;
  /**
   * 箱子高 比较(gte)
   */
  private java.math.BigDecimal boxHeightGte;
  /**
   * 箱子高 比较(lt)
   */
  private java.math.BigDecimal boxHeightLt;
  /**
   * 箱子高 比较(lte)
   */
  private java.math.BigDecimal boxHeightLte;
  /**
   * 箱子高 比较(contains)
   */
  private java.math.BigDecimal boxHeightContains;
  /**
   * 箱子高 比较(notcontains)
   */
  private java.math.BigDecimal boxHeightNotcontains;
  /**
   * 箱子高 比较(startswith)
   */
  private java.math.BigDecimal boxHeightStartswith;
  /**
   * 箱子高 比较(endswith)
   */
  private java.math.BigDecimal boxHeightEndswith;
  /**
   * 箱子高 比较(isnull)
   */
  private Boolean boxHeightIsnull;
  /**
   * 箱子高 比较(isnotnull)
   */
  private Boolean boxHeightIsnotnull;

  /**
   * 单箱数量
   */
  private java.math.BigDecimal quantityInCase;

  /**
   * 最小单箱数量
   */
  private java.math.BigDecimal quantityInCaseMin;

  /**
   * 最大单箱数量
   */
  private java.math.BigDecimal quantityInCaseMax;

  /**
   * 单箱数量 比较(eq)
   */
  private java.math.BigDecimal quantityInCaseEq;
  /**
   * 单箱数量 比较(neq)
   */
  private java.math.BigDecimal quantityInCaseNeq;
  /**
   * 单箱数量 比较(gt)
   */
  private java.math.BigDecimal quantityInCaseGt;
  /**
   * 单箱数量 比较(gte)
   */
  private java.math.BigDecimal quantityInCaseGte;
  /**
   * 单箱数量 比较(lt)
   */
  private java.math.BigDecimal quantityInCaseLt;
  /**
   * 单箱数量 比较(lte)
   */
  private java.math.BigDecimal quantityInCaseLte;
  /**
   * 单箱数量 比较(contains)
   */
  private java.math.BigDecimal quantityInCaseContains;
  /**
   * 单箱数量 比较(notcontains)
   */
  private java.math.BigDecimal quantityInCaseNotcontains;
  /**
   * 单箱数量 比较(startswith)
   */
  private java.math.BigDecimal quantityInCaseStartswith;
  /**
   * 单箱数量 比较(endswith)
   */
  private java.math.BigDecimal quantityInCaseEndswith;
  /**
   * 单箱数量 比较(isnull)
   */
  private Boolean quantityInCaseIsnull;
  /**
   * 单箱数量 比较(isnotnull)
   */
  private Boolean quantityInCaseIsnotnull;

  /**
   * 总重量（kg）
   */
  private java.math.BigDecimal tatolWeight;

  /**
   * 最小总重量（kg）
   */
  private java.math.BigDecimal tatolWeightMin;

  /**
   * 最大总重量（kg）
   */
  private java.math.BigDecimal tatolWeightMax;

  /**
   * 总重量（kg） 比较(eq)
   */
  private java.math.BigDecimal tatolWeightEq;
  /**
   * 总重量（kg） 比较(neq)
   */
  private java.math.BigDecimal tatolWeightNeq;
  /**
   * 总重量（kg） 比较(gt)
   */
  private java.math.BigDecimal tatolWeightGt;
  /**
   * 总重量（kg） 比较(gte)
   */
  private java.math.BigDecimal tatolWeightGte;
  /**
   * 总重量（kg） 比较(lt)
   */
  private java.math.BigDecimal tatolWeightLt;
  /**
   * 总重量（kg） 比较(lte)
   */
  private java.math.BigDecimal tatolWeightLte;
  /**
   * 总重量（kg） 比较(contains)
   */
  private java.math.BigDecimal tatolWeightContains;
  /**
   * 总重量（kg） 比较(notcontains)
   */
  private java.math.BigDecimal tatolWeightNotcontains;
  /**
   * 总重量（kg） 比较(startswith)
   */
  private java.math.BigDecimal tatolWeightStartswith;
  /**
   * 总重量（kg） 比较(endswith)
   */
  private java.math.BigDecimal tatolWeightEndswith;
  /**
   * 总重量（kg） 比较(isnull)
   */
  private Boolean tatolWeightIsnull;
  /**
   * 总重量（kg） 比较(isnotnull)
   */
  private Boolean tatolWeightIsnotnull;

  /**
   * 总体积重
   */
  private java.math.BigDecimal tatolVolumeWeight;

  /**
   * 最小总体积重
   */
  private java.math.BigDecimal tatolVolumeWeightMin;

  /**
   * 最大总体积重
   */
  private java.math.BigDecimal tatolVolumeWeightMax;

  /**
   * 总体积重 比较(eq)
   */
  private java.math.BigDecimal tatolVolumeWeightEq;
  /**
   * 总体积重 比较(neq)
   */
  private java.math.BigDecimal tatolVolumeWeightNeq;
  /**
   * 总体积重 比较(gt)
   */
  private java.math.BigDecimal tatolVolumeWeightGt;
  /**
   * 总体积重 比较(gte)
   */
  private java.math.BigDecimal tatolVolumeWeightGte;
  /**
   * 总体积重 比较(lt)
   */
  private java.math.BigDecimal tatolVolumeWeightLt;
  /**
   * 总体积重 比较(lte)
   */
  private java.math.BigDecimal tatolVolumeWeightLte;
  /**
   * 总体积重 比较(contains)
   */
  private java.math.BigDecimal tatolVolumeWeightContains;
  /**
   * 总体积重 比较(notcontains)
   */
  private java.math.BigDecimal tatolVolumeWeightNotcontains;
  /**
   * 总体积重 比较(startswith)
   */
  private java.math.BigDecimal tatolVolumeWeightStartswith;
  /**
   * 总体积重 比较(endswith)
   */
  private java.math.BigDecimal tatolVolumeWeightEndswith;
  /**
   * 总体积重 比较(isnull)
   */
  private Boolean tatolVolumeWeightIsnull;
  /**
   * 总体积重 比较(isnotnull)
   */
  private Boolean tatolVolumeWeightIsnotnull;

  /**
   * 单品净重
   */
  private java.math.BigDecimal oneSuttle;

  /**
   * 最小单品净重
   */
  private java.math.BigDecimal oneSuttleMin;

  /**
   * 最大单品净重
   */
  private java.math.BigDecimal oneSuttleMax;

  /**
   * 单品净重 比较(eq)
   */
  private java.math.BigDecimal oneSuttleEq;
  /**
   * 单品净重 比较(neq)
   */
  private java.math.BigDecimal oneSuttleNeq;
  /**
   * 单品净重 比较(gt)
   */
  private java.math.BigDecimal oneSuttleGt;
  /**
   * 单品净重 比较(gte)
   */
  private java.math.BigDecimal oneSuttleGte;
  /**
   * 单品净重 比较(lt)
   */
  private java.math.BigDecimal oneSuttleLt;
  /**
   * 单品净重 比较(lte)
   */
  private java.math.BigDecimal oneSuttleLte;
  /**
   * 单品净重 比较(contains)
   */
  private java.math.BigDecimal oneSuttleContains;
  /**
   * 单品净重 比较(notcontains)
   */
  private java.math.BigDecimal oneSuttleNotcontains;
  /**
   * 单品净重 比较(startswith)
   */
  private java.math.BigDecimal oneSuttleStartswith;
  /**
   * 单品净重 比较(endswith)
   */
  private java.math.BigDecimal oneSuttleEndswith;
  /**
   * 单品净重 比较(isnull)
   */
  private Boolean oneSuttleIsnull;
  /**
   * 单品净重 比较(isnotnull)
   */
  private Boolean oneSuttleIsnotnull;

  /**
   * 单品毛重
   */
  private java.math.BigDecimal oneGross;

  /**
   * 最小单品毛重
   */
  private java.math.BigDecimal oneGrossMin;

  /**
   * 最大单品毛重
   */
  private java.math.BigDecimal oneGrossMax;

  /**
   * 单品毛重 比较(eq)
   */
  private java.math.BigDecimal oneGrossEq;
  /**
   * 单品毛重 比较(neq)
   */
  private java.math.BigDecimal oneGrossNeq;
  /**
   * 单品毛重 比较(gt)
   */
  private java.math.BigDecimal oneGrossGt;
  /**
   * 单品毛重 比较(gte)
   */
  private java.math.BigDecimal oneGrossGte;
  /**
   * 单品毛重 比较(lt)
   */
  private java.math.BigDecimal oneGrossLt;
  /**
   * 单品毛重 比较(lte)
   */
  private java.math.BigDecimal oneGrossLte;
  /**
   * 单品毛重 比较(contains)
   */
  private java.math.BigDecimal oneGrossContains;
  /**
   * 单品毛重 比较(notcontains)
   */
  private java.math.BigDecimal oneGrossNotcontains;
  /**
   * 单品毛重 比较(startswith)
   */
  private java.math.BigDecimal oneGrossStartswith;
  /**
   * 单品毛重 比较(endswith)
   */
  private java.math.BigDecimal oneGrossEndswith;
  /**
   * 单品毛重 比较(isnull)
   */
  private Boolean oneGrossIsnull;
  /**
   * 单品毛重 比较(isnotnull)
   */
  private Boolean oneGrossIsnotnull;

  /**
   * 包装规格（cm）长
   */
  private java.math.BigDecimal packageLength;

  /**
   * 最小包装规格（cm）长
   */
  private java.math.BigDecimal packageLengthMin;

  /**
   * 最大包装规格（cm）长
   */
  private java.math.BigDecimal packageLengthMax;

  /**
   * 包装规格（cm）长 比较(eq)
   */
  private java.math.BigDecimal packageLengthEq;
  /**
   * 包装规格（cm）长 比较(neq)
   */
  private java.math.BigDecimal packageLengthNeq;
  /**
   * 包装规格（cm）长 比较(gt)
   */
  private java.math.BigDecimal packageLengthGt;
  /**
   * 包装规格（cm）长 比较(gte)
   */
  private java.math.BigDecimal packageLengthGte;
  /**
   * 包装规格（cm）长 比较(lt)
   */
  private java.math.BigDecimal packageLengthLt;
  /**
   * 包装规格（cm）长 比较(lte)
   */
  private java.math.BigDecimal packageLengthLte;
  /**
   * 包装规格（cm）长 比较(contains)
   */
  private java.math.BigDecimal packageLengthContains;
  /**
   * 包装规格（cm）长 比较(notcontains)
   */
  private java.math.BigDecimal packageLengthNotcontains;
  /**
   * 包装规格（cm）长 比较(startswith)
   */
  private java.math.BigDecimal packageLengthStartswith;
  /**
   * 包装规格（cm）长 比较(endswith)
   */
  private java.math.BigDecimal packageLengthEndswith;
  /**
   * 包装规格（cm）长 比较(isnull)
   */
  private Boolean packageLengthIsnull;
  /**
   * 包装规格（cm）长 比较(isnotnull)
   */
  private Boolean packageLengthIsnotnull;

  /**
   * 包装规格（cm）宽
   */
  private java.math.BigDecimal packageWeight;

  /**
   * 最小包装规格（cm）宽
   */
  private java.math.BigDecimal packageWeightMin;

  /**
   * 最大包装规格（cm）宽
   */
  private java.math.BigDecimal packageWeightMax;

  /**
   * 包装规格（cm）宽 比较(eq)
   */
  private java.math.BigDecimal packageWeightEq;
  /**
   * 包装规格（cm）宽 比较(neq)
   */
  private java.math.BigDecimal packageWeightNeq;
  /**
   * 包装规格（cm）宽 比较(gt)
   */
  private java.math.BigDecimal packageWeightGt;
  /**
   * 包装规格（cm）宽 比较(gte)
   */
  private java.math.BigDecimal packageWeightGte;
  /**
   * 包装规格（cm）宽 比较(lt)
   */
  private java.math.BigDecimal packageWeightLt;
  /**
   * 包装规格（cm）宽 比较(lte)
   */
  private java.math.BigDecimal packageWeightLte;
  /**
   * 包装规格（cm）宽 比较(contains)
   */
  private java.math.BigDecimal packageWeightContains;
  /**
   * 包装规格（cm）宽 比较(notcontains)
   */
  private java.math.BigDecimal packageWeightNotcontains;
  /**
   * 包装规格（cm）宽 比较(startswith)
   */
  private java.math.BigDecimal packageWeightStartswith;
  /**
   * 包装规格（cm）宽 比较(endswith)
   */
  private java.math.BigDecimal packageWeightEndswith;
  /**
   * 包装规格（cm）宽 比较(isnull)
   */
  private Boolean packageWeightIsnull;
  /**
   * 包装规格（cm）宽 比较(isnotnull)
   */
  private Boolean packageWeightIsnotnull;

  /**
   * 包装规格（cm）高
   */
  private java.math.BigDecimal packageHeight;

  /**
   * 最小包装规格（cm）高
   */
  private java.math.BigDecimal packageHeightMin;

  /**
   * 最大包装规格（cm）高
   */
  private java.math.BigDecimal packageHeightMax;

  /**
   * 包装规格（cm）高 比较(eq)
   */
  private java.math.BigDecimal packageHeightEq;
  /**
   * 包装规格（cm）高 比较(neq)
   */
  private java.math.BigDecimal packageHeightNeq;
  /**
   * 包装规格（cm）高 比较(gt)
   */
  private java.math.BigDecimal packageHeightGt;
  /**
   * 包装规格（cm）高 比较(gte)
   */
  private java.math.BigDecimal packageHeightGte;
  /**
   * 包装规格（cm）高 比较(lt)
   */
  private java.math.BigDecimal packageHeightLt;
  /**
   * 包装规格（cm）高 比较(lte)
   */
  private java.math.BigDecimal packageHeightLte;
  /**
   * 包装规格（cm）高 比较(contains)
   */
  private java.math.BigDecimal packageHeightContains;
  /**
   * 包装规格（cm）高 比较(notcontains)
   */
  private java.math.BigDecimal packageHeightNotcontains;
  /**
   * 包装规格（cm）高 比较(startswith)
   */
  private java.math.BigDecimal packageHeightStartswith;
  /**
   * 包装规格（cm）高 比较(endswith)
   */
  private java.math.BigDecimal packageHeightEndswith;
  /**
   * 包装规格（cm）高 比较(isnull)
   */
  private Boolean packageHeightIsnull;
  /**
   * 包装规格（cm）高 比较(isnotnull)
   */
  private Boolean packageHeightIsnotnull;

  /**
   * 是否有 图片
   */
  private Boolean picUrl;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
